home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / m68k / 68343ffp.arc / FFPDIV.SA < prev    next >
Text File  |  1989-08-30  |  7KB  |  168 lines
  1.          TTL       FAST FLOATING POINT DIVIDE (FFPDIV)
  2. *****************************************
  3. *  (C) COPYRIGHT 1980 BY MOTOROLA INC.  *
  4. *****************************************
  5.  
  6. ********************************************
  7. *           FFPDIV SUBROUTINE              *
  8. *                                          *
  9. * INPUT:                                   *
  10. *        D6 - FLOATING POINT DIVISOR       *
  11. *        D7 - FLOATING POINT DIVIDEND      *
  12. *                                          *
  13. * OUTPUT:                                  *
  14. *        D7 - FLOATING POINT QUOTIENT      *
  15. *                                          *
  16. * CONDITION CODES:                         *
  17. *        N - SET IF RESULT NEGATIVE        *
  18. *        Z - SET IF RESULT ZERO            *
  19. *        V - SET IF RESULT OVERFLOWED      *
  20. *        C - UNDEFINED                     *
  21. *        X - UNDEFINED                     *
  22. *                                          *
  23. * REGISTERS D3 THRU D5 VOLATILE            *
  24. *                                          *
  25. * CODE: 150 BYTES     STACK WORK: 0 BYTES  *
  26. *                                          *
  27. * NOTES:                                   *
  28. *   1) DIVISOR IS UNALTERED (D6).          *
  29. *   2) UNDERFLOWS RETURN ZERO WITHOUT      *
  30. *      ANY INDICATORS SET.                 *
  31. *   3) OVERFLOWS RETURN THE HIGHEST VALUE  *
  32. *      WITH THE PROPER SIGN AND THE 'V'    *
  33. *      BIT SET IN THE CCR.                 *
  34. *   4) IF A DIVIDE BY ZERO IS ATTEMPTED    *
  35. *      THE DIVIDE BY ZERO EXCEPTION TRAP   *
  36. *      IS FORCED BY THIS CODE WITH THE     *
  37. *      ORIGINAL ARGUMENTS INTACT.  IF THE  *
  38. *      EXCEPTION RETURNS WITH THE DENOM-   *
  39. *      INATOR ALTERED THE DIVIDE OPERATION *
  40. *      CONTINUES, OTHERWISE AN OVERFLOW    *
  41. *      IS FORCED WITH THE PROPER SIGN.     *
  42. *      THE FLOATING DIVIDE BY ZERO CAN BE  *
  43. *      DISTINGUISHED FROM TRUE ZERO DIVIDE *
  44. *      BY THE FACT THAT IT IS AN IMMEDIATE *
  45. *      ZERO DIVIDING INTO REGISTER D7.     *
  46. *                                          *
  47. * TIME: (8 MHZ NO WAIT STATES ASSUMED)     *
  48. * DIVIDEND ZERO         5.250 MICROSECONDS *
  49. * MINIMUM TIME OTHERS  72.750 MICROSECONDS *
  50. * MAXIMUM TIME OTHERS  85.000 MICROSECONDS *
  51. * AVERAGE OTHERS       76.687 MICROSECONDS *
  52. *                                          *
  53. ********************************************
  54.          PAGE
  55. FFPDIV   IDNT      1,1  FFP DIVIDE
  56.  
  57.          XDEF      FFPDIV     ENTRY POINT
  58.          XREF      FFPCPYRT   COPYRIGHT NOTICE
  59.  
  60.          SECTION    9
  61.  
  62. * DIVIDE BY ZERO EXIT
  63. FPDDZR DIVU.W #0,D7     **FORCE DIVIDE BY ZERO **
  64.  
  65. * IF THE EXCEPTION RETURNS WITH ALTERED DENOMINATOR - CONTINUE DIVIDE
  66.          TST.L     D6        ? EXCEPTION ALTER THE ZERO
  67.          BNE.S     FFPDIV    BRANCH IF SO TO CONTINUE
  68. * SETUP MAXIMUM NUMBER FOR DIVIDE OVERFLOW
  69. FPDOVF OR.L   #$FFFFFF7F,D7 MAXIMIZE WITH PROPER SIGN
  70.        TST.B  D7        SET CONDITION CODE FOR SIGN
  71. *      OR.W   #$02,CCR  SET OVERFLOW BIT
  72.        DC.L   $003C0002 ******SICK ASSEMBLER******
  73. FPDRTN RTS              RETURN TO CALLER
  74.  
  75. * OVER OR UNDERFLOW DETECTED
  76. FPDOV2   SWAP.W    D6        RESTORE ARG1
  77.          SWAP.W    D7        RESTORE ARG2 FOR SIGN
  78. FPDOVFS EOR.B  D6,D7     SETUP CORRECT SIGN
  79.        BRA.S  FPDOVF    AND ENTER OVERFLOW HANDLING
  80. FPDOUF BMI.S  FPDOVFS   BRANCH IF OVERFLOW
  81. FPDUND MOVE.L #0,D7     UNDERFLOW TO ZERO
  82.        RTS              AND RETURN TO CALLER
  83.  
  84. ***************
  85. * ENTRY POINT *
  86. ***************
  87.  
  88. * FIRST SUBTRACT EXPONENTS
  89. FFPDIV MOVE.B D6,D5     COPY ARG1 (DIVISOR)
  90.        BEQ.S  FPDDZR    BRANCH IF DIVIDE BY ZERO
  91.        MOVE.L D7,D4     COPY ARG2 (DIVIDEND)
  92.        BEQ.S  FPDRTN    RETURN ZERO IF DIVIDEND ZERO
  93.        MOVEQ  #-128,D3  SETUP SIGN MASK
  94.        ADD.W  D5,D5     ISOLATE ARG1 SIGN FROM EXPONENT
  95.        ADD.W  D4,D4     ISOLATE ARG2 SIGN FROM EXPONENT
  96.        EOR.B  D3,D5     ADJUST ARG1 EXPONENT TO BINARY
  97.        EOR.B  D3,D4     ADJUST ARG2 EXPONENT TO BINARY
  98.        SUB.B  D5,D4     SUBTRACT EXPONENTS
  99.        BVS.S  FPDOUF    BRANCH IF OVERFLOW/UNDERFLOW
  100.        CLR.B  D7        CLEAR ARG2 S+EXP
  101.        SWAP.W D7        PREPARE HIGH 16 BIT COMPARE
  102.        SWAP.W D6        AGAINST ARG1 AND ARG2
  103.        CMP.W  D6,D7     ? CHECK IF OVERFLOW WILL OCCUR
  104.        BMI.S  FPDNOV    BRANCH IF NOT
  105. * ADJUST FOR FIXED POINT DIVIDE OVERFLOW
  106.        ADD.B  #2,D4     ADJUST EXPONENT UP ONE
  107.        BVS.S  FPDOV2    BRANCH OVERFLOW HERE
  108.        ROR.L  #1,D7     SHIFT DOWN BY POWER OF TWO
  109. FPDNOV SWAP.W D7        CORRECT ARG2
  110.        MOVE.B D3,D5     MOVE $80 INTO D5.B
  111.        EOR.W  D5,D4     CREATE SIGN AND ABSOLUTIZE EXPONENT
  112.        LSR.W  #1,D4     D4.B NOW HAS SIGN+EXPONENT OF RESULT
  113.  
  114. * NOW DIVIDE JUST USING 16 BITS INTO 24
  115.        MOVE.L D7,D3     COPY ARG1 FOR INITIAL DIVIDE
  116.        DIVU.W D6,D3     OBTAIN TEST QUOTIENT
  117.        MOVE.W D3,D5     SAVE TEST QUOTIENT
  118.  
  119. * NOW MULTIPLY 16-BIT DIVIDE RESULT TIMES FULL 24 BIT DIVISOR AND COMPARE
  120. * WITH THE DIVIDEND.  MULTIPLYING BACK OUT WITH THE FULL 24-BITS ALLOWS
  121. * US TO SEE IF THE RESULT WAS TOO LARGE DUE TO THE 8 MISSING DIVISOR BITS
  122. * USED IN THE HARDWARE DIVIDE.  THE RESULT CAN ONLY BE TOO LARGE BY 1 UNIT.
  123.        MULU.W D6,D3     HIGH DIVISOR X QUOTIENT
  124.        SUB.L  D3,D7     D7=PARTIAL SUBTRACTION
  125.        SWAP.W D7        TO LOW DIVISOR
  126.        SWAP.W D6        REBUILD ARG1 TO NORMAL
  127.        MOVE.W D6,D3     SETUP ARG1 FOR PRODUCT
  128.        CLR.B  D3        ZERO LOW BYTE
  129.        MULU.W D5,D3     FIND REMAINING PRODUCT
  130.        SUB.L  D3,D7     NOW HAVE FULL SUBTRACTION
  131.        BCC.S  FPDQOK    BRANCH FIRST 16 BITS CORRECT
  132.  
  133. * ESTIMATE TOO HIGH, DECREMENT QUOTIENT BY ONE
  134.        MOVE.L D6,D3     REBUILD DIVISOR
  135.        CLR.B  D3        REVERSE HALVES
  136.        ADD.L  D3,D7     ADD ANOTHER DIVISOR
  137.        SUB.W  #1,D5     DECREMENT QUOTIENT
  138.  
  139. * COMPUTE LAST 8 BITS WITH ANOTHER DIVIDE.  THE EXACT REMAINDER FROM THE
  140. * MULTIPLY AND COMPARE ABOVE IS DIVIDED AGAIN BY A 16-BIT ONLY DIVISOR.
  141. * HOWEVER, THIS TIME WE REQUIRE ONLY 9 BITS OF ACCURACY IN THE RESULT
  142. * (8 TO MAKE 24 BITS TOTAL AND 1 EXTRA BIT FOR ROUNDING PURPOSES) AND THIS
  143. * DIVIDE ALWAYS RETURNS A PRECISION OF AT LEAST 9 BITS.
  144. FPDQOK MOVE.L D6,D3     COPY ARG1 AGAIN
  145.        SWAP.W D3        FIRST 16 BITS DIVISOR IN D3.W
  146.        CLR.W  D7        INTO FIRST 16 BITS OF DIVIDEND
  147.        DIVU.W D3,D7     OBTAIN FINAL 16 BIT RESULT
  148.        SWAP.W D5        FIRST 16 QUOTIENT TO HIGH HALF
  149.        BMI.S  FPDISN    BRANCH IF NORMALIZED
  150. * RARE OCCURRANCE - UNNORMALIZED
  151. * HAPPENDS WHEN MANTISSA ARG1 < ARG2 AND THEY DIFFER ONLY IN LAST 8 BITS
  152.        MOVE.W D7,D5     INSERT LOW WORD OF QUOTIENT
  153.        ADD.L  D5,D5     SHIFT MANTISSA LEFT ONE
  154.        SUB.B  #1,D4     ADJUST EXPONENT DOWN (CANNOT ZERO)
  155.        MOVE.W D5,D7     CANCEL NEXT INSTRUCTION
  156.  
  157. * REBUILD OUR FINAL RESULT AND RETURN
  158. FPDISN MOVE.W D7,D5     APPEND NEXT 16 BITS
  159.        ADD.L  #$80,D5   ROUND TO 24 BITS (CANNOT OVERFLOW)
  160.        MOVE.L D5,D7     RETURN IN D7
  161.        MOVE.B D4,D7     FINISH RESULT WITH SIGN+EXPONENT
  162.        BEQ.S  FPDUND    UNDERFLOW IF ZERO EXPONENT
  163.        RTS              RETURN RESULT TO CALLER
  164.  
  165.  
  166.        END
  167.  
  168.